{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01. DQN\n",
    "\n",
    "[V. Mnih et al., \"Human-level control through deep reinforcement learning.\" Nature, 518\n",
    "(7540):529–533, 2015.](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)\n",
    "\n",
    "Reinforcement learning is known to be unstable or even to diverge when a nonlinear function approximator such as a neural network is used to represent the action-value (also known as $Q$) function. This instability has several causes: the correlations present in the sequence of observations, the fact that small updates to $Q$ may significantly change the policy and therefore change the data distribution, and the correlations between the action-values ($Q$) and the target values $r + \\gamma \\max_{a'} Q(s', a')$.\n",
    "\n",
    "The authors suggest two key ideas to address these instabilities with a novel variant of Q-learning: Replay buffer and Fixed Q-target.\n",
    "\n",
    "#### Uniformly random sampling from Experience Replay Memory\n",
    "\n",
    "\n",
    "Reinforcement learning agent stores the experiences consecutively in the buffer, so adjacent ($s, a, r, s'$) transitions stored are highly likely to have correlation. To remove this, the agent samples experiences uniformly at random from the pool of stored samples $\\big( (s, a, r, s') \\sim U(D) \\big)$. See sample_batch method of ReplayBuffer class for more details.\n",
    "#### Fixed Q-target\n",
    "\n",
    "\n",
    "DQN uses an iterative update that adjusts the action-values ($Q$) towards target values that are only periodically updated, thereby reducing correlations with the target; if not, it is easily divergy because the target continuously moves. The Q-learning update at iteration $i$ uses the following loss function:\n",
    "\n",
    "\n",
    "$$\n",
    "L_i(\\theta_i) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} \\big[ \\big( r + \\gamma \\max_{a'} Q(s',a';\\theta_i^-) - Q(s, a; \\theta_i) \\big)^2 \\big]\n",
    "$$\n",
    "\n",
    "in which $\\gamma$ is the discount factor determining the agent’s horizon, $\\theta_i$ are the parameters of the Q-network at iteration $i$ and $\\theta_i^-$ are the network parameters used to compute the target at iteration $i$. The target network parameters $\\theta_i^-$ are only updated with the Q-network parameters ($\\theta_i$) every C steps and are held fixed between individual updates. ($C = 200$ in CartPole-v0)\n",
    "\n",
    "#### For more stability: Gradient clipping\n",
    "\n",
    "\n",
    "The authors also found it helpful to clip the error term from the update $r + \\gamma \\max_{a'} Q(s', a'; \\theta_i^-) - Q(s,a,;\\theta_i)$ to be between -1 and 1. Because the absolute value loss function $|x|$ has a derivative of -1 for all negative values of x and a derivative of 1 for all positive values of x, clipping the squared error to be between -1 and 1 corresponds to using an absolute value loss function for errors outside of the (-1,1) interval. This form of error clipping further improved the stability of the algorithm.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "重放缓冲区\n",
    "\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "  - collections.deque\n",
    "  - list\n",
    "  - numpy.ndarray\n",
    "\n",
    "通常，人们使用以下三种数据结构之一来实现重放缓冲区：\n",
    "\n",
    "  - collections.deque\n",
    "  - list\n",
    "  - numpy.ndarray\n",
    "  \n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of  *Get item* is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "一旦初始化了 deque 的最大长度（例如 deque(maxlen=buffer_size)），**deque** 就很容易处理了。但是，由于 deque 是[内部双链路 list](https://wiki.python.org/moin/TimeComplexity#collections.deque)，随着它的增长，索引操作会变得非常慢。另一方面，**list** 是一个数组，因此在每一步都进行批量采样时，它的速度相对要比 deque 快。其*Get item*的摊销成本为[O(1)](https://wiki.python.org/moin/TimeComplexity#list)。\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference). Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "最后，让我们来看看**numpy.ndarray**。numpy.ndarray比list更快，因为它是[由固定大小项组成的同质数组](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray)，所以你可以获得[引用的局部性](https://en.wikipedia.org/wiki/Locality_of_reference)的好处。而 list 是一个指向对象的指针数组，即使所有对象都是同一类型。\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "在这里，我们将使用 numpy.ndarray 实现重放缓冲区。\n",
    "\n",
    "Reference: [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU).\n",
    "\n",
    "我们将使用一个简单的网络结构，包括三个全连接层和两个非线性函数（ReLU）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        # 理论上其他网络是否会有更好的效果？\n",
    "        # 探索LSTM等其他网络结构的效果？\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        print('obs_dim is:')\n",
    "        print(obs_dim) # size 4 横向速度，横向位置，单摆角度，单摆角速度\n",
    "        action_dim = env.action_space.n\n",
    "        print('action_dim is:')\n",
    "        print(action_dim) # size 2 左右\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)  # value function v_a(s)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()  # 随机采样动作空间， 探索策略\n",
    "        else:\n",
    "            # 贪婪策略 ，选取softmax 概率最大的 动作，离散动作空间\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device) # reshape成1列 long type\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # print(action)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action) # gather详解\n",
    "\n",
    "        # curr_q_value.view(torch.long)\n",
    "\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss \n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "        # 这个误差函数具有梯度裁剪效果，查看pytorch手册（https://pytorch.org/docs/stable/generated/torch.nn.SmoothL1Loss.html）\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "obs_dim is:\n",
      "4\n",
      "action_dim is:\n",
      "2\n",
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video d:\\QT\\rainbow-is-all-you-need\\videos\\dqn\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video d:\\QT\\rainbow-is-all-you-need\\videos\\dqn\\rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                             "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready d:\\QT\\rainbow-is-all-you-need\\videos\\dqn\\rl-video-episode-0.mp4\n",
      "score:  74.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/dqn\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/dqn\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
